package org.cleverframe.common.utils;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 反射工具类<br>
 * 1.提供调用getter/setter方法<br>
 * 2.访问私有变量, 调用私有方法<br>
 * 3.获取泛型类型Class<br>
 * 4.被AOP过的真实类<br>
 * 
 * @author LiZW
 * @version 2015年5月28日 下午1:32:25
 */
public class Reflections
{
	/** setter方法前缀 */
	private static final String SETTER_PREFIX = "set";
	/** getter方法前缀 */
	private static final String GETTER_PREFIX = "get";
	/** CGLib生成的类的分隔标记 */
	private static final String CGLIB_CLASS_SEPARATOR = "$$";
	/** slf4j日志记录器 */
	private final static Logger logger = LoggerFactory.getLogger(Reflections.class);

	/**
	 * 调用Getter方法<br>
	 * 支持多级，如：对象名.对象名.方法<br>
	 */
	public static Object invokeGetter(Object obj, String propertyName)
	{
		Object object = obj;
		for (String name : StringUtils.split(propertyName, "."))
		{
			String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(name);
			object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
		}
		return object;
	}

	/**
	 * 调用Setter方法, 仅匹配方法名<br>
	 * 支持多级，如：对象名.对象名.方法<br>
	 */
	public static void invokeSetter(Object obj, String propertyName, Object value)
	{
		Object object = obj;
		String[] names = StringUtils.split(propertyName, ".");
		for (int i = 0; i < names.length; i++)
		{
			if (i < names.length - 1)
			{
				String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(names[i]);
				object = invokeMethod(object, getterMethodName, new Class[] {}, new Object[] {});
			}
			else
			{
				String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(names[i]);
				invokeMethodByName(object, setterMethodName, new Object[] { value });
			}
		}
	}

	/**
	 * 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数<br>
	 */
	public static Object getFieldValue(final Object obj, final String fieldName)
	{
		Field field = getAccessibleField(obj, fieldName);

		if (field == null)
		{
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
		}

		Object result = null;
		try
		{
			result = field.get(obj);
		}
		catch (IllegalAccessException e)
		{
			logger.error("不可能抛出的异常{}", e.getMessage());
		}
		return result;
	}

	/**
	 * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数<br>
	 */
	public static void setFieldValue(final Object obj, final String fieldName, final Object value)
	{
		Field field = getAccessibleField(obj, fieldName);

		if (field == null)
		{
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
		}

		try
		{
			field.set(obj, value);
		}
		catch (IllegalAccessException e)
		{
			logger.error("不可能抛出的异常:{}", e.getMessage());
		}
	}

	/**
	 * 直接调用对象方法, 无视private/protected修饰符<br>
	 * 用于一次性调用的情况，否则应使用getAccessibleMethod()函数获得Method后反复调用<br>
	 * 同时匹配方法名+参数类型<br>
	 */
	public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes, final Object[] args)
	{
		Method method = getAccessibleMethod(obj, methodName, parameterTypes);
		if (method == null)
		{
			throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
		}

		try
		{
			return method.invoke(obj, args);
		}
		catch (Exception e)
		{
			throw convertReflectionExceptionToUnchecked(e);
		}
	}

	/**
	 * 直接调用对象方法, 无视private/protected修饰符<br>
	 * 用于一次性调用的情况，否则应使用getAccessibleMethodByName()函数获得Method后反复调用<br>
	 * 只匹配函数名，如果有多个同名函数调用第一个<br>
	 */
	public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args)
	{
		Method method = getAccessibleMethodByName(obj, methodName);
		if (method == null)
		{
			throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
		}

		try
		{
			return method.invoke(obj, args);
		}
		catch (Exception e)
		{
			throw convertReflectionExceptionToUnchecked(e);
		}
	}

	/**
	 * 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问<br>
	 * 如向上转型到Object仍无法找到, 返回null<br>
	 */
	public static Field getAccessibleField(final Object obj, final String fieldName)
	{
		Validate.notNull(obj, "object can't be null");
		Validate.notBlank(fieldName, "fieldName can't be blank");
		for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass())
		{
			try
			{
				Field field = superClass.getDeclaredField(fieldName);
				makeAccessible(field);
				return field;
			}
			catch (NoSuchFieldException e)
			{// NOSONAR
				// Field不在当前类定义,继续向上转型
				continue;// new add
			}
		}
		return null;
	}

	/**
	 * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问<br>
	 * 如向上转型到Object仍无法找到, 返回null<br>
	 * 匹配函数名+参数类型<br>
	 * 
	 * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)<br>
	 */
	public static Method getAccessibleMethod(final Object obj, final String methodName, final Class<?>... parameterTypes)
	{
		Validate.notNull(obj, "object can't be null");
		Validate.notBlank(methodName, "methodName can't be blank");

		for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass())
		{
			try
			{
				Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
				makeAccessible(method);
				return method;
			}
			catch (NoSuchMethodException e)
			{
				// Method不在当前类定义,继续向上转型
				continue;// new add
			}
		}
		return null;
	}

	/**
	 * 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问<br>
	 * 如向上转型到Object仍无法找到, 返回null<br>
	 * 只匹配函数名<br>
	 * 
	 * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object... args)<br>
	 */
	public static Method getAccessibleMethodByName(final Object obj, final String methodName)
	{
		Validate.notNull(obj, "object can't be null");
		Validate.notBlank(methodName, "methodName can't be blank");

		for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType.getSuperclass())
		{
			Method[] methods = searchType.getDeclaredMethods();
			for (Method method : methods)
			{
				if (method.getName().equals(methodName))
				{
					makeAccessible(method);
					return method;
				}
			}
		}
		return null;
	}

	/**
	 * 改变private/protected的方法为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨<br>
	 */
	public static void makeAccessible(Method method)
	{
		if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible())
		{
			method.setAccessible(true);
		}
	}

	/**
	 * 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨<br>
	 */
	public static void makeAccessible(Field field)
	{
		if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier.isFinal(field.getModifiers()))
				&& !field.isAccessible())
		{
			field.setAccessible(true);
		}
	}

	/**
	 * 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处<br>
	 * 如无法找到, 返回Object.class.
	 * eg.
	 * public UserDao extends HibernateDao<User><br>
	 *
	 * @param clazz The class to introspect
	 * @return the first generic declaration, or Object.class if cannot be determined
	 */
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static <T> Class<T> getClassGenricType(final Class clazz)
	{
		return getClassGenricType(clazz, 0);
	}

	/**
	 * 通过反射, 获得Class定义中声明的父类的泛型参数的类型<br>
	 * 如无法找到, 返回Object.class<br>
	 * 
	 * 如public UserDao extends HibernateDao<User,Long><br>
	 *
	 * @param clazz clazz The class to introspect
	 * @param index the Index of the generic ddeclaration,start from 0.
	 * @return the index generic declaration, or Object.class if cannot be determined
	 */
	@SuppressWarnings("rawtypes")
	public static Class getClassGenricType(final Class clazz, final int index)
	{
		Type genType = clazz.getGenericSuperclass();

		if (!(genType instanceof ParameterizedType))
		{
			logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
			return Object.class;
		}

		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

		if (index >= params.length || index < 0)
		{
			logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " + params.length);
			return Object.class;
		}
		if (!(params[index] instanceof Class))
		{
			logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
			return Object.class;
		}

		return (Class) params[index];
	}

	@SuppressWarnings("rawtypes")
	public static Class<?> getUserClass(Object instance)
	{
		Validate.notNull(instance, "Instance must not be null");
		Class clazz = instance.getClass();
		if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR))
		{
			Class<?> superClass = clazz.getSuperclass();
			if (superClass != null && !Object.class.equals(superClass))
			{
				return superClass;
			}
		}
		return clazz;

	}

	/**
	 * 将反射时的checked exception转换为unchecked exception<br>
	 */
	public static RuntimeException convertReflectionExceptionToUnchecked(Exception e)
	{
		if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException || e instanceof NoSuchMethodException)
		{
			return new IllegalArgumentException(e);
		}
		else if (e instanceof InvocationTargetException)
		{
			return new RuntimeException(((InvocationTargetException) e).getTargetException());
		}
		else if (e instanceof RuntimeException)
		{
			return (RuntimeException) e;
		}
		return new RuntimeException("Unexpected Checked Exception.", e);
	}
}
